home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 2: Applications / Linux Cubed Series 2 - Applications.iso / math / gle-3.000 / gle-3 / gle / d_bmp.c < prev    next >
C/C++ Source or Header  |  1995-02-07  |  13KB  |  579 lines
  1. /*--------------------------------------------------------------*/
  2. /*  Bitmap Driver 1.0 (VAX C, TURBO  C) , for GLE V3.0  */
  3. /*--------------------------------------------------------------*/
  4. /* This version writes the PATH to a temporary file which can
  5. /* then be read by a bitmap driver (which has more memory available) */
  6. /*---------------------------------------------------------------------------*/
  7. #include "all.h"
  8. #include <math.h>
  9. #include "core.h"
  10. #include "mygraph.h"
  11. #include "mydev.h"
  12. #ifndef __TURBOC__
  13. #define huge
  14. #else
  15. #include <alloc.h>
  16. #endif
  17. extern int dev_fill,dev_font;
  18. extern int gunit;
  19. extern struct gmodel g;
  20. /*---------------------------------------------------------------------------*/
  21. #define pi 3.141592653
  22. #define false 0
  23. #define true (!false)
  24. #define dbg if ((gle_debug & 64)>0)
  25. extern int gle_debug;
  26. int getch(void);
  27. int kbhit(void);
  28.  
  29.  
  30. int path_newpath(void);
  31. int path_lwidth(float x);
  32. int path_stroke(void);
  33. int path_fill(void);
  34. int path_lstyle(int32 x);
  35. int path_dashlen(float x);
  36. int path_dline(float x,float y);
  37. int path_size(float x,float y);
  38. int path_row(float x1, float y1, float x2, float y2);
  39. int path_box(float x1, float y1, float x2, float y2);
  40. int dpath_box(double x1, double  y1, double  x2, double y2);
  41. int path_alloc(void);
  42. int path_move(float x1, float y1);
  43. int path_line(float x1, float y1);
  44. int path_closepath(void);
  45. /*---------------------------------------------------------------------------*/
  46. int32 d_curcolor,d_curfill;
  47. /*---------------------------------------------------------------------------*/
  48. /*   Path variables for bitmap */
  49. typedef union {int32 l; float f;} longfloat;
  50. longfloat *path;
  51. int npath;
  52. int npath_alloc;
  53.  
  54. #include "dvipath.h"
  55. path_reset()
  56. {
  57. }
  58. path_newpath(void)
  59. {
  60.     path_alloc();
  61.     path[npath++].l = p_newpath;
  62. }
  63. path_move(float x,float y)
  64. {
  65.     path_alloc();
  66.     path[npath++].l = p_move;
  67.     path[npath++].f = x;
  68.     path[npath++].f = y;
  69. }
  70. path_lwidth(float x)
  71. {
  72.     path_alloc();
  73.     path[npath++].l = p_lwidth;
  74.     path[npath++].f = x;
  75. }
  76. path_setcolor(int r, int g, int b, int f)
  77. {
  78.     path_alloc();
  79.     path[npath++].l = p_setcolor;
  80.     path[npath++].l = r;
  81.     path[npath++].l = g;
  82.     path[npath++].l = b;
  83.     path[npath++].l = f;
  84. }
  85. path_stroke(void)
  86. {
  87.     path_alloc();
  88.     path[npath++].l = p_stroke;
  89. }
  90. path_fill(void)
  91. {
  92.     path_alloc();
  93.     path[npath++].l = p_fill;
  94. }
  95. path_int(int x)
  96. {
  97.     path_alloc();
  98.     path[npath++].l = x;
  99. }
  100. path_lstyle(int32 x)
  101. {
  102.     path_alloc();
  103.     path[npath++].l = p_lstyle;
  104.     path[npath++].l = x;
  105. }
  106. path_dline(float x,float y)
  107. {
  108.     path_alloc();
  109.     path[npath++].l = p_dline;
  110.     path[npath++].f = x;
  111.     path[npath++].f = y;
  112. }
  113. path_size(float x,float y)
  114. {
  115.     path_alloc();
  116.     path[npath++].l = p_size;
  117.     path[npath++].f = x;
  118.     path[npath++].f = y;
  119. }
  120. path_dashlen(float x)
  121. {
  122.     path_alloc();
  123.     path[npath++].l = p_dashlen;
  124.     path[npath++].f = x;
  125. }
  126. path_line(float x,float y)
  127. {
  128.     path_alloc();
  129.     path[npath++].l = p_line;
  130.     path[npath++].f = x;
  131.     path[npath++].f = y;
  132. }
  133. path_bezier(float x1, float y1, float x2, float y2,float x3, float y3)
  134. {
  135.     path_alloc();
  136.     path[npath++].l = p_bezier;
  137.     path[npath++].f = x1;   path[npath++].f = y1;
  138.     path[npath++].f = x2;   path[npath++].f = y2;
  139.     path[npath++].f = x3;   path[npath++].f = y3;
  140. }
  141. path_closepath()
  142. {
  143.     path_alloc();
  144.     path[npath++].l = p_closepath;
  145. }
  146. path_box(float x1, float y1, float x2, float y2)
  147. {
  148.     path_move(x1,y1);
  149.     path_line(x2,y1);
  150.     path_line(x2,y2);
  151.     path_line(x1,y2);
  152.     path_closepath();
  153. }
  154. path_alloc(void)
  155. {
  156.     static int npa;
  157.     int32 *a;
  158.     if (npath > 100) path_flush();
  159.     if (npath < (npath_alloc-20)) return;
  160.     npath_alloc = 20 + 2 * npath;
  161.     a = myallocz(npath_alloc*sizeof(int32));
  162.     if (a==NULL) {
  163.         gle_abort("Unable to allocate memory for path \n");
  164.     }
  165.     if (path != NULL) {
  166.         memcpy(a,path,(npa)*sizeof(int32));
  167.         myfree(path);
  168.     }
  169.     npa = npath_alloc;
  170.     path = (longfloat *) a;
  171. }
  172. path_free(void)
  173. {
  174.     if (path==NULL) return;
  175.     myfree(path);
  176.     path = NULL;
  177.     npath = 0;
  178.     npath_alloc = 0;
  179. }
  180.  
  181. d_devcmd(char *s)
  182. {}
  183. dxy(double x, double y, float *dx, float *dy)
  184. {
  185.     static double fx,fy;
  186.     g_dev(x,y,&fx,&fy);
  187.     *dx = fx;
  188.     *dy = fy;
  189. }
  190. rxy(double x, double y, int *dx, int *dy)
  191. {
  192.     static double fx,fy,zx,zy;
  193.     g_dev(x,y,&fx,&fy);
  194.     g_dev(0.0,0.0,&zx,&zy);
  195.     *dx = (int) ( (fx-zx) );
  196.     *dy = (int) ( (fy-zy) );
  197. }
  198. /*---------------------------------------------------------------------------*/
  199. d_dfont(char *c)
  200. {
  201.     /* only used for the DFONT driver which builds fonts (never used)*/
  202. }
  203. /*---------------------------------------------------------------------------*/
  204. d_message(char *s)
  205. {
  206.     printf("%s\n",s);
  207. }
  208. /*---------------------------------------------------------------------------*/
  209. d_source(char *s)
  210. {
  211.     s=s;
  212. }
  213. /*---------------------------------------------------------------------------*/
  214. d_get_type(char *t)
  215. {
  216.     strcpy(t,"OUTPUT, BITMAP, BLACKANDWHITE, HARDCOPY, FILLPATH");
  217. }
  218. /*---------------------------------------------------------------------------*/
  219. d_set_path(int onoff)
  220. {
  221. }
  222. /*---------------------------------------------------------------------------*/
  223. d_newpath()
  224. {
  225.     path_flush();
  226.     path_newpath();
  227. }
  228. /*---------------------------------------------------------------------------*/
  229. FILE *dout;
  230. path_flush(void)
  231. {
  232.     if (npath>0) fwrite(path,sizeof(int32),npath,dout);
  233.     npath = 0;
  234. }
  235. d_open(double width, double height)
  236. {
  237.     char *outfile;
  238.     outfile = "out.dvi";
  239.     dout = fopen(outfile,"wb");
  240.     if (dout == NULL) gle_abort("Unable to open OUT.dvi epson output file \n");
  241.     path_alloc();
  242.     path_size(width,height);
  243.     if (!dev_font) plotter_fonts();
  244. }
  245. /*---------------------------------------------------------------------------*/
  246. d_tidyup()
  247. {
  248.     gprint("AARRRrrrrgg,  watch out I'm dying!!!\n");
  249. }
  250. d_close()
  251. {
  252.     g_flush();
  253.     path_flush();
  254.     path_free();
  255.     fclose(dout);
  256. #ifndef unix
  257. #ifdef DJ /* a.r. */
  258.     printf("Now enter one of:\n");
  259.     printf("   gle_dvip -depson [-hires] (to print to a dot matrix printer)\n");
  260.     printf("   gle_dvip -dlj    [-hires] (to print to HP LaserJet/Deskjet)\n");
  261.     printf("   gle_dvip -dpj    [-hires] (to print to HP Paintjet)\n");
  262.     printf("   gle_dvip -dvt             (Preview on screen)\n");
  263.     printf("   gle_dvip                  (to see other valid qualifiers)\n");
  264. #else
  265.     printf("Now enter one of:\n");
  266.     printf("   dviprint -depson [-hires] (to print to a dot matrix printer)\n");
  267.     printf("   dviprint -dlj    [-hires] (to print to HP LaserJet/Deskjet)\n");
  268.     printf("   dviprint -dpj    [-hires] (to print to HP Paintjet)\n");
  269.     printf("   dviprint -dvt             (Preview on screen)\n");
  270.     printf("   dviprint                  (to see other valid qualifiers)\n");
  271. #endif
  272. #endif
  273. }
  274. /*---------------------------------------------------------------------------*/
  275. d_set_line_cap(int i)
  276. {
  277.     i++;
  278. }
  279. /*---------------------------------------------------------------------------*/
  280. d_set_line_join(int i)
  281. {
  282.     i++;
  283. }
  284. /*---------------------------------------------------------------------------*/
  285. d_set_line_miterlimit(double d)
  286. {
  287.     int i=0;
  288.     i++;
  289. }
  290. /*---------------------------------------------------------------------------*/
  291. d_set_line_width(double w)
  292. {
  293.     float dx,dy,zx,zy;
  294.  
  295.     dxy(w,w,&dx,&dy);
  296.     dxy(0.0,0.0,&zx,&zy);
  297.     path_lwidth(sqrt(pow(dx-zx,2) + pow(dy-zy,2)));
  298.     path_lwidth(w);
  299. }
  300. /*---------------------------------------------------------------------------*/
  301. d_set_line_styled(double dd)
  302. {
  303.     path_dashlen(dd);
  304. }
  305. d_set_line_style(char *s)
  306. {
  307.     static char *defline[] = {"","","12","41","14","92",
  308.         "1282","9229","4114","54"};
  309.     int i,j,nblack,nwhite;
  310.     char *ss;
  311.     int32 pat;
  312. /* lstyle pattern output in dvi file is a 32 bit integer:
  313.       First 27 bits (starting with MSB) is the pattern, last 5 bits
  314.       (bits 0 to 4) is one less than the number of the last bit in the pattern.
  315.       This allows continuous patterns (no funny glitches every 32 dots).
  316. */
  317.  
  318.     if (!g.inpath) g_flush();
  319.     if (strlen(s)==1) s = defline[*s-'0'];
  320.     if (strcmp(s,"")==0) {
  321.         pat = 0x8000001e;   /* pattern is one dot repeated */
  322.         path_lstyle(pat);
  323.         return;
  324.     }
  325.     ss = s;
  326.  
  327.         pat = 0;                 /* make up to 27 bit pattern from digits */
  328.     for (i=31; i>4;) {
  329.         nblack = *s - '0';
  330.         s++;
  331.         for (j=0; j<nblack; j++) {
  332.         pat = pat | (1L << i);
  333.         i--;
  334.         }
  335.         if (*s == 0)  s = ss;   /* if odd number of digits, repeat */
  336.         nwhite = *s - '0';
  337.         s++;
  338.         i = i - nwhite;
  339.         if (*s == 0) {          /* stop if at end of digit string */
  340.                 if (i < 4)  i = 4;
  341.                 pat = (pat & 0xffffffe0) | i;
  342.                 break;
  343.             }
  344.     }
  345.     path_lstyle(pat);
  346. /*        printf ("Pattern: %s %X  %d\n", ss, pat, pat&0x1f); */
  347. }
  348. /*---------------------------------------------------------------------------*/
  349. d_fill()
  350. {
  351.     set_fill();
  352.     path_fill();
  353.     set_color();
  354. }
  355. /*---------------------------------------------------------------------------*/
  356. d_fill_ary(int nwk,double (*wkx)[],double (*wky)[])
  357. {
  358.     int i;
  359.  
  360.     path_move( (*wkx)[0], (*wky)[0]);
  361.     for (i=1;i<nwk;i++) {
  362.         path_line( (*wkx)[i], (*wky)[i]);
  363.     }
  364.     d_fill();
  365. }
  366. d_line_ary(int nwk,double (*wkx)[],double (*wky)[])
  367. {
  368.     int i;
  369.  
  370.     path_move( (*wkx)[0], (*wky)[0]);
  371.     for (i=1;i<nwk;i++) {
  372.         path_line( (*wkx)[i], (*wky)[i]);
  373.     }
  374.     d_stroke();
  375. }
  376. /*---------------------------------------------------------------------------*/
  377. d_stroke()
  378. {
  379.     path_stroke();
  380. }
  381. /*---------------------------------------------------------------------------*/
  382. d_clip()
  383. {
  384.     path_int(p_clip);
  385. }
  386. /*---------------------------------------------------------------------------*/
  387. d_set_matrix(double newmat[3][3])
  388. {
  389.  
  390. }
  391. /*---------------------------------------------------------------------------*/
  392. d_move(double zx,double zy)
  393. {
  394.  
  395. }
  396. /*---------------------------------------------------------------------------*/
  397. d_reverse()     /* reverse the order of stuff in the current path */
  398. {
  399. }
  400. /*---------------------------------------------------------------------------*/
  401. d_closepath()
  402. {
  403.     path_closepath();
  404. }
  405. int bit_line( double x, double y);
  406. /*---------------------------------------------------------------------------*/
  407. d_line(double zx,double zy)
  408. {
  409.     float dx,dy;
  410.     if (g.xinline==false) {
  411.         dxy(g.curx,g.cury,&dx,&dy);
  412.         path_move(dx,dy);
  413.     }
  414.     if (g.inpath==false) {
  415.         dxy(zx,zy,&dx,&dy);
  416.         path_dline(dx,dy);
  417.         return;
  418.     }
  419.     dxy(zx,zy,&dx,&dy);
  420.     path_line(dx,dy);
  421. }
  422. /*---------------------------------------------------------------------------*/
  423. d_clear()
  424. {
  425. }
  426. /*---------------------------------------------------------------------------*/
  427. d_flush()
  428. {
  429. }
  430. /*---------------------------------------------------------------------------*/
  431. d_arcto(dbl x1,dbl y1,dbl x2,dbl y2,dbl rrr)
  432. {
  433.     df_arcto(x1,y1,x2,y2,rrr);
  434. }
  435. /*---------------------------------------------------------------------------*/
  436. d_arc(dbl r,dbl t1,dbl t2,dbl cx,dbl cy)
  437. {
  438.     df_arc(r,t1,t2,cx,cy);
  439. }
  440. /*---------------------------------------------------------------------------*/
  441. d_narc(dbl r,dbl t1,dbl t2,dbl cx,dbl cy)
  442. {
  443.     /* swap t1 t2 a.r. */
  444.     df_arc(r,t2,t1,cx,cy);
  445. }
  446. /*---------------------------------------------------------------------------*/
  447. d_box_fill(dbl x1, dbl y1, dbl x2, dbl y2)
  448. {
  449.     set_fill();
  450.     if (g.inpath==true) dpath_box(x1,y1,x2,y2);
  451.     else {
  452.         g_flush();
  453.         d_newpath();
  454.         dpath_box(x1,y1,x2,y2);
  455.         d_fill();
  456.     }
  457.     set_color();
  458. }
  459. d_box_stroke(dbl x1, dbl y1, dbl x2, dbl y2)
  460. {
  461.     if (g.inpath==true) df_box_stroke(x1,y1,x2,y2);
  462.     else {
  463.         g_flush();
  464.         d_newpath();
  465.         df_box_stroke(x1,y1,x2,y2);
  466.         d_stroke();
  467.     }
  468. }
  469. /*---------------------------------------------------------------------------*/
  470. d_circle_stroke(double zr)
  471. {
  472.     double xx,yy;
  473.     g_get_xy(&xx,&yy);
  474.     df_circle_stroke(zr);
  475.     g_move(xx,yy);
  476. }
  477. d_circle_fill(double zr)
  478. {
  479.     int savep;
  480.     double xx,yy;
  481.     g_get_xy(&xx,&yy);
  482.     savep = g.inpath;
  483.     if (!g.inpath) {g_flush();  d_newpath();}
  484.     g.inpath = true;
  485.     set_fill();
  486.     df_circle_fill(zr);
  487.     d_fill();
  488.     set_color();
  489.     g.inpath = savep;
  490.     if (!g.inpath) {d_newpath();}
  491.     g_move(xx,yy);
  492. }
  493. /*---------------------------------------------------------------------------*/
  494. int df_bezier(dbl x1,dbl y1,dbl x2,dbl y2,dbl x3,dbl y3);
  495. d_bezier(dbl x1,dbl y1,dbl x2,dbl y2,dbl x3,dbl y3)
  496. {
  497.     float dx1,dy1,dx2,dy2,dx3,dy3,dx0,dy0;
  498.  
  499.     if (!g.xinline || !g.inpath) {
  500.         dxy(g.curx,g.cury,&dx0,&dy0);
  501.         path_move(dx0,dy0);
  502.     }
  503.  
  504.     dxy(x1,y1,&dx1,&dy1);
  505.     dxy(x2,y2,&dx2,&dy2);
  506.     dxy(x3,y3,&dx3,&dy3);
  507.  
  508.     path_bezier(dx1,dy1,dx2,dy2,dx3,dy3);
  509.     if (!g.inpath) {d_stroke(); d_newpath();}
  510. }
  511. dpath_box(dbl x1,dbl y1,dbl x2,dbl y2)
  512. {
  513.     float dx1,dy1,dx2,dy2,dx3,dy3,dx4,dy4;
  514.  
  515.     dxy(x1,y1,&dx1,&dy1);
  516.     dxy(x2,y1,&dx2,&dy2);
  517.     dxy(x2,y2,&dx3,&dy3);
  518.     dxy(x1,y2,&dx4,&dy4);
  519.  
  520.     path_move(dx1,dy1);
  521.     path_line(dx2,dy2);
  522.     path_line(dx3,dy3);
  523.     path_line(dx4,dy4);
  524.     path_closepath();
  525. }
  526. /*---------------------------------------------------------------------------*/
  527. set_color()
  528. {
  529.     colortyp cc;
  530.     cc.l = d_curcolor;
  531.     path_setcolor(cc.b[B_R],cc.b[B_G],cc.b[B_B],cc.b[B_F]);
  532. }
  533. set_fill()
  534. {
  535.     colortyp cc;
  536.     cc.l = d_curfill;
  537.     path_setcolor(cc.b[B_R],cc.b[B_G],cc.b[B_B],cc.b[B_F]);
  538. }
  539. d_set_color(int32 f)
  540. {
  541.     d_curcolor = f;
  542.     set_color();
  543. }
  544. d_set_fill(int32 f)
  545. {
  546.     d_curfill = f;
  547. }
  548. /*---------------------------------------------------------------------------*/
  549. d_beginclip()
  550. {
  551.     path_int(p_saveclip);
  552. }
  553. d_endclip()
  554. {
  555.     path_int(p_restoreclip);
  556. }
  557. struct char_data {float wx,wy,x1,y1,x2,y2; };
  558. int font_get_chardata(struct char_data **cd, int ff, int cc);
  559. /*---------------------------------------------------------------------------*/
  560. int safnt;
  561. int simple_char(int cc);
  562. d_char(int font, int cc)
  563. {
  564.     static struct char_data cd;
  565.     static int ix1,ix2,iy1,iy2;
  566.     static int ux,uy;
  567.     char ss[2];
  568.  
  569.     ss[0] = cc;
  570.     ss[1] = 0;
  571.     if (safnt==0) safnt = pass_font("PLSR");
  572.     if (font_get_encoding(font)>2) {
  573.         my_char(font,cc);
  574.         return;
  575.     }
  576.     my_char(safnt,cc);
  577. }
  578.  
  579.